import { useEffect, useMemo, useState } from 'react'

type IRoute = {
  name: string
  path: string
  children?: any[]
  roles?: string[]
  ignoreRoute?: boolean
}

const routes: IRoute[] = [
  {
    name: 'home',
    path: '/home',
    roles: ['ROLE_ADMIN'],
  },
  {
    name: 'myTasks',
    path: '/myTasks',
    roles: ['ROLE_ADMIN', 'ROLE_USER'],
  },
  {
    name: 'user',
    path: '/user',
    roles: ['ROLE_ADMIN'],
  },
]

/**
 * 根据用户权限过滤路由
 * @returns [IRoute[], string] 返回过滤后的路由和默认路由
 */
export const useRoute = (authority: string[]): [IRoute[], string] => {
  /**
   * 递归过滤路由
   * @param routes 路由数组
   * @param arr 过滤后的路由数组
   * @returns IRoute[] 返回过滤后的路由数组
   */
  const filterRoute = (routes: IRoute[], arr: IRoute[] = []): IRoute[] => {
    // 如果路由数组为空，直接返回空数组
    if (!routes.length) {
      return []
    }
    // 遍历路由数组
    for (const route of routes) {
      // 获取当前路由的 key
      const { roles, ignoreRoute } = route
      // 判断当前路由是否可见
      let visible: boolean | undefined = true
      if (roles && authority) {
        visible = authority.some((value) => roles.includes(value)) || ignoreRoute
      }

      // 如果当前路由不可见，继续下一个路由
      if (!visible) {
        continue
      }
      // 如果当前路由有子路由
      if (route.children && route.children.length) {
        // 创建一个新的路由，清空子路由
        const newRoute = { ...route, children: [] }
        // 递归过滤子路由
        filterRoute(route.children, newRoute.children)
        // 如果子路由不为空，将新路由添加到过滤后的路由数组中
        if (newRoute.children.length) {
          arr.push(newRoute)
        }
      } else {
        // 将当前路由添加到过滤后的路由数组中
        arr.push({ ...route })
      }
    }

    return arr
  }

  // 初始化过滤后的路由数组
  const [permissionRoute, setPermissionRoute] = useState(routes)

  // 使用Effect钩子来过滤路由
  useEffect(() => {
    // 过滤路由
    const newRoutes = filterRoute(routes)
    console.table(newRoutes)
    // 更新过滤后的路由数组
    setPermissionRoute(newRoutes)
    // 因为依赖于用户权限，所以不需要额外的依赖项
  }, [JSON.stringify(authority)])

  // 使用 useMemo 钩子来计算默认路由
  const defaultRoute = useMemo(() => {
    // 获取过滤后的路由数组的第一个路由
    const first = permissionRoute[0]
    if (first) {
      // 获取第一个路由的子路由的第一个路由的 key，如果不存在则获取第一个路由的 key
      const firstRoute = first?.children?.[0]?.path || first.path
      return firstRoute
    }
    return ''
  }, [permissionRoute])

  // 返回过滤后的路由数组和默认路由
  return [permissionRoute, defaultRoute]
}

export const DefaultPath = (authority: string[]) => {
  const filterRoute = (routes: IRoute[], arr: IRoute[] = []): IRoute[] => {
    // 如果路由数组为空，直接返回空数组
    if (!routes.length) {
      return []
    }
    // 遍历路由数组
    for (const route of routes) {
      // 获取当前路由的 key
      const { roles, ignoreRoute } = route
      // 判断当前路由是否可见
      let visible: boolean | undefined = true
      if (roles) {
        visible = authority.some((value) => roles.includes(value)) || ignoreRoute
      }

      // 如果当前路由不可见，继续下一个路由
      if (!visible) {
        continue
      }
      // 如果当前路由有子路由
      if (route.children && route.children.length) {
        // 创建一个新的路由，清空子路由
        const newRoute = { ...route, children: [] }
        // 递归过滤子路由
        filterRoute(route.children, newRoute.children)
        // 如果子路由不为空，将新路由添加到过滤后的路由数组中
        if (newRoute.children.length) {
          arr.push(newRoute)
        }
      } else {
        // 将当前路由添加到过滤后的路由数组中
        arr.push({ ...route })
      }
    }

    return arr
  }
  const newRoutes = filterRoute(routes)
  const first = newRoutes[0]
  if (first) {
    // 获取第一个路由的子路由的第一个路由的 key，如果不存在则获取第一个路由的 key
    const firstRoute = first?.children?.[0]?.path || first.path
    return firstRoute
  }

  return ''
}
